package Socketserver;

import Socketserver.SQL.ForMysql;
import Socketserver.SQL.ROOT;

import java.util.List;
import java.util.Map;
import java.util.Random;

public class TestCenter {

    // 程序入口
    public static void main(String[] args) {
        TestCenter testCenter = new TestCenter();
        testCenter.centers(); // 启动测试
    }

    // 测试入口方法
    public void centers() {
        System.out.println("===== 开始测试 =====");

        // 1. 初始化核心实例（假设Medium类负责初始化ROOT和ForMysql，此处简化实现）
        ROOT root = new ROOT();
        ForMysql forMysql = new ForMysql(
                root.iT_CAN_MOVE_OR_NOT,
                root.getDriver(),
                root.getUrl(),
                root.getUsername(),
                root.getPassword(),
                root.getDATAABSE_NAME(),
                root.getThe_table_name(),
                root.getThe_TXTTable_name()
        );

        // 2. 验证数据库连接
        System.out.println("\n===== 验证数据库连接 =====");
        root.ROOT_TEST();
        if (!root.iT_CAN_MOVE_OR_NOT) {
            System.out.println("数据库连接失败，终止测试");
            return;
        }
        System.out.println("ROOT_TEST 没有问题");

        // 3. 创建数据库
        System.out.println("\n===== 创建数据库MY_SQL_SERVER =====");
        root.root_USE_SQL_ForOnly_CREATEDATABASE();
        if (checkDatabaseExists(root)) {
            System.out.println("root_USE_SQL_ForOnly_CREATEDATABASE 没有问题");
        } else {
            System.out.println("root_USE_SQL_ForOnly_CREATEDATABASE 存在问题");
        }

        // 4. 创建表
        System.out.println("\n===== 创建用户表和TXT表 =====");
        root.root_create_SQL_table(); // 创建用户表
        root.root_create_SQLTXT_table(); // 创建TXT表
        if (checkTableExists(root, root.getThe_table_name()) && checkTableExists(root, root.getThe_TXTTable_name())) {
            System.out.println("表创建操作 没有问题");
        } else {
            System.out.println("表创建操作 存在问题");
        }

        // 5. 测试用户表操作
        System.out.println("\n===== 测试用户表（USER_Table）操作 =====");
        testUserTableOperations(forMysql, root);

        // 6. 测试TXT表操作
        System.out.println("\n===== 测试TXT表（TXT_Table）操作 =====");
        testTxtTableOperations(forMysql, root);

        // 7. 测试清理
        System.out.println("\n===== 测试清理 =====");
        root.root_drop_SQL_table(); // 删除用户表
        root.root_drop_SQLTXT_table(); // 删除TXT表
        root.root_USE_SQL_ForOnly_DROPDATABASE(); // 删除数据库

        // 增加延迟确保删除操作完成
        try {
            Thread.sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        // 验证：检查数据库和表是否已删除
        if (!checkDatabaseExists(root) &&
                !checkTableExists(root, root.getThe_table_name()) &&
                !checkTableExists(root, root.getThe_TXTTable_name())) {
            System.out.println("清理操作 没有问题");
        } else {
            System.out.println("清理操作 存在问题");
        }

        System.out.println("\n===== 所有测试执行完毕 =====");
    }

    // 测试用户表增删改查
    private void testUserTableOperations(ForMysql forMysql, ROOT root) {
        Random random = new Random();
        String testUserId = "TEST_USER_" + System.currentTimeMillis();
        String testUserName = "test_user_" + random.nextInt(1000);

        // 5.1 插入用户
        System.out.println("\n--- 插入用户 ---");
        boolean insertSuccess = forMysql.INSERT_INTO_TABLE_User(
                testUserId,
                testUserName,
                "test_pwd",
                "test_type",
                0
        );
        List<Map<String, String>> insertResult = forMysql.SELECT_FROM_FIND_MY_Account(
                testUserId,
                root.getTable_id()
        );
        if (insertSuccess && !insertResult.isEmpty()) {
            System.out.println("INSERT_INTO_TABLE_User 没有问题");
        } else {
            System.out.println("INSERT_INTO_TABLE_User 存在问题");
        }

        // 5.2 模糊删除用户
        System.out.println("\n--- 模糊删除用户 ---");
        String deleteKey = testUserName.substring(0, 5); // 取用户名前5位作为模糊删除条件
        boolean deleteSuccess = forMysql.DELETE_TABLE_User_What(
                root.getTable_name(),
                "%" + deleteKey + "%"
        );
        // 延迟确保删除完成
        try {
            Thread.sleep(300);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        List<Map<String, String>> deleteResult = forMysql.SELECT_FROM_FIND_MY_Account(
                deleteKey,
                root.getTable_name()
        );
        if (deleteSuccess && deleteResult.isEmpty()) {
            System.out.println("DELETE_TABLE_User_What 没有问题");
        } else {
            System.out.println("DELETE_TABLE_User_What 存在问题");
        }

        // 5.3 修改用户（修正参数匹配问题）
        System.out.println("\n--- 修改用户 ---");
        String updateUserId = "UPDATE_USER_" + System.currentTimeMillis(); // 待修改用户的ID
        String oldName = "old_name_" + random.nextInt(1000); // 原始名称
        // 先插入一条待修改的测试数据
        forMysql.INSERT_INTO_TABLE_User(
                updateUserId,
                oldName,
                "update_pwd",
                "update_type",
                0
        );
        String newName = "new_name_" + random.nextInt(1000); // 新名称
        // 调用修改方法（补充id参数，匹配最新方法定义）
        boolean alterSuccess = forMysql.ALTER_TABLE_User_What(
                updateUserId,                // 待修改用户的ID（新增参数）
                root.getTable_name(),        // 要修改的字段（name）
                oldName,                     // 字段旧值（用于匹配）
                newName                      // 字段新值
        );
        // 验证修改结果
        List<Map<String, String>> updateResult = forMysql.SELECT_FROM_FIND_MY_Account(
                newName,
                root.getTable_name()
        );
        if (alterSuccess && !updateResult.isEmpty()) {
            System.out.println("ALTER_TABLE_User_What 没有问题");
        } else {
            System.out.println("ALTER_TABLE_User_What 存在问题");
        }

        // 5.4 查询用户
        System.out.println("\n--- 查询用户 ---");
        List<Map<String, String>> queryResult = forMysql.SELECT_FROM_FIND_MY_Account(
                "",
                root.getTable_name()
        );
        if (queryResult != null) {
            System.out.println("SELECT_FROM_FIND_MY_Account 没有问题");
        } else {
            System.out.println("SELECT_FROM_FIND_MY_Account 存在问题");
        }

        // 5.5 root查询全表用户
        System.out.println("\n--- root查询全表用户 ---");
        List<Map<String, String>> rootQueryResult = root.SELECT_TABLE_FOR_ALL_Table_rootss(
                root.getThe_table_name(),
                root.getTable_id(),
                ""
        );
        if (rootQueryResult != null) {
            System.out.println("SELECT_TABLE_FOR_ALL_Table_rootss（用户表） 没有问题");
        } else {
            System.out.println("SELECT_TABLE_FOR_ALL_Table_rootss（用户表） 存在问题");
        }

        // 5.6 root清空用户表
        System.out.println("\n--- root清空用户表 ---");
        root.root_drop_SQL_table_FORUser("", "");
        List<Map<String, String>> clearResult = forMysql.SELECT_FROM_FIND_MY_Account(
                "",
                root.getTable_name()
        );
        if (clearResult.isEmpty()) {
            System.out.println("root_drop_SQL_table_FORUser（清空） 没有问题");
        } else {
            System.out.println("root_drop_SQL_table_FORUser（清空） 存在问题");
        }
    }

    // 测试TXT表增删改查
    private void testTxtTableOperations(ForMysql forMysql, ROOT root) {
        Random random = new Random();
        String testTxtId = "TEST_TXT_" + System.currentTimeMillis();
        String testTxtName = "test_txt_" + random.nextInt(1000);
        String testAuthor = "root"; // 符合删除时的作者校验

        // 6.1 插入TXT记录
        System.out.println("\n--- 插入TXT记录 ---");
        boolean insertSuccess = forMysql.INSERT_INTO_TABLE_txt(
                testTxtId,
                testTxtName,
                "/test/path",
                testAuthor
        );
        List<Map<String, String>> insertResult = forMysql.SELECT_FROM_FIND_MY_TXT(
                testTxtId,
                root.getTXT_TABLE_id()
        );
        if (insertSuccess && !insertResult.isEmpty()) {
            System.out.println("INSERT_INTO_TABLE_txt 没有问题");
        } else {
            System.out.println("INSERT_INTO_TABLE_txt 存在问题");
        }

        // 6.2 模糊删除TXT记录
        System.out.println("\n--- 模糊删除TXT记录 ---");
        String deleteKey = testTxtName.substring(0, 5);
        boolean deleteSuccess = forMysql.DELETE_TABLE_txt_What(
                root.getTXT_TABLE_name(),
                "%" + deleteKey + "%",
                testAuthor
        );
        // 延迟确保删除完成
        try {
            Thread.sleep(300);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        List<Map<String, String>> deleteResult = forMysql.SELECT_FROM_FIND_MY_TXT(
                deleteKey,
                root.getTXT_TABLE_name()
        );
        if (deleteSuccess && deleteResult.isEmpty()) {
            System.out.println("DELETE_TABLE_txt_What 没有问题");
        } else {
            System.out.println("DELETE_TABLE_txt_What 存在问题");
        }

        // 6.3 修改TXT记录
        System.out.println("\n--- 修改TXT记录 ---");
        String updateTxtId = "UPDATE_TXT_" + System.currentTimeMillis();
        String oldTxtName = "old_txt_" + random.nextInt(1000);
        forMysql.INSERT_INTO_TABLE_txt(
                updateTxtId,
                oldTxtName,
                "/update/path",
                "update_author"
        );
        String newTxtName = "new_txt_" + random.nextInt(1000);
        boolean alterSuccess = forMysql.ALTER_TABLE_txt_What(
                root.getTXT_TABLE_name(),
                oldTxtName,
                newTxtName
        );
        List<Map<String, String>> updateResult = forMysql.SELECT_FROM_FIND_MY_TXT(
                newTxtName,
                root.getTXT_TABLE_name()
        );
        if (alterSuccess && !updateResult.isEmpty()) {
            System.out.println("ALTER_TABLE_txt_What 没有问题");
        } else {
            System.out.println("ALTER_TABLE_txt_What 存在问题");
        }

        // 6.4 查询TXT记录
        System.out.println("\n--- 查询TXT记录 ---");
        List<Map<String, String>> queryResult = forMysql.SELECT_FROM_FIND_MY_TXT(
                "",
                root.getTXT_TABLE_name()
        );
        if (queryResult != null) {
            System.out.println("SELECT_FROM_FIND_MY_TXT 没有问题");
        } else {
            System.out.println("SELECT_FROM_FIND_MY_TXT 存在问题");
        }

        // 6.5 root查询全表TXT
        System.out.println("\n--- root查询全表TXT ---");
        List<Map<String, String>> rootQueryResult = root.SELECT_TABLE_FOR_ALL_Table_rootss(
                root.getThe_TXTTable_name(),
                root.getTXT_TABLE_id(),
                ""
        );
        if (rootQueryResult != null) {
            System.out.println("SELECT_TABLE_FOR_ALL_Table_rootss（TXT表） 没有问题");
        } else {
            System.out.println("SELECT_TABLE_FOR_ALL_Table_rootss（TXT表） 存在问题");
        }

        // 6.6 root清空TXT表
        System.out.println("\n--- root清空TXT表 ---");
        root.root_drop_SQL_table_FORTxt("", "");
        List<Map<String, String>> clearResult = forMysql.SELECT_FROM_FIND_MY_TXT(
                "",
                root.getTXT_TABLE_name()
        );
        if (clearResult.isEmpty()) {
            System.out.println("root_drop_SQL_table_FORTxt（清空） 没有问题");
        } else {
            System.out.println("root_drop_SQL_table_FORTxt（清空） 存在问题");
        }
    }

    // 辅助方法：检查数据库是否存在
    private boolean checkDatabaseExists(ROOT root) {
        String sql = "SELECT SCHEMA_NAME FROM INFORMATION_SCHEMA.SCHEMATA WHERE SCHEMA_NAME = '" + root.getDATAABSE_NAME() + "'";
        List<Map<String, String>> result = root.root_FIND_SQL_ForOnly_TABLE(sql, "SCHEMA_NAME");
        return !result.isEmpty();
    }

    // 辅助方法：检查表是否存在
    private boolean checkTableExists(ROOT root, String tableName) {
        String sql = "SELECT TABLE_NAME FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_SCHEMA = '" + root.getDATAABSE_NAME() + "' AND TABLE_NAME = '" + tableName + "'";
        List<Map<String, String>> result = root.root_FIND_SQL_ForOnly_TABLE(sql, "TABLE_NAME");
        return !result.isEmpty();
    }
}